//
// nel3d.java
// Copyright (C) 2010  "Naush" <naush _ hotmail _ fr>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>./* ----------------------------------------------------------------------------







package org.ryzom.nel.threed;

import org.ryzom.nel.misc.CRGBA;
import org.ryzom.nel.misc.CRGBAF;
import org.ryzom.nel.misc.CUV;
import org.ryzom.nel.misc.CVector;

public class nel3d implements nel3dConstants {
  public static CVector blend(CVector v0, CVector v1, float lambda) {
    return new CVector(nel3dJNI.blend__SWIG_0(CVector.getCPtr(v0), v0, CVector.getCPtr(v1), v1, lambda), true);
  }

  public static double getPi() {
    return nel3dJNI.Pi_get();
  }

  public static float frand(float mod) {
    return nel3dJNI.frand(mod);
  }

  public static int fsgn(double f) {
    return nel3dJNI.fsgn(f);
  }

  public static long raiseToNextPowerOf2(long v) {
    return nel3dJNI.raiseToNextPowerOf2(v);
  }

  public static long getPowerOf2(long v) {
    return nel3dJNI.getPowerOf2(v);
  }

  public static boolean isPowerOf2(int v) {
    return nel3dJNI.isPowerOf2(v);
  }

  public static float degToRad(float deg) {
    return nel3dJNI.degToRad(deg);
  }

  public static float radToDeg(float rad) {
    return nel3dJNI.radToDeg(rad);
  }

  public static double isValidDouble(double v) {
    return nel3dJNI.isValidDouble(v);
  }

  public static String toLower(String str) {
    return nel3dJNI.toLower__SWIG_0(str);
  }

  public static char toLower(char ch) {
    return nel3dJNI.toLower__SWIG_2(ch);
  }

  public static String toUpper(String str) {
    return nel3dJNI.toUpper__SWIG_0(str);
  }

  public static SWIGTYPE_p_std__string strlwr(SWIGTYPE_p_std__string str) {
    return new SWIGTYPE_p_std__string(nel3dJNI.strlwr__SWIG_0(SWIGTYPE_p_std__string.getCPtr(str)), false);
  }

  public static String strlwr(String str) {
    return nel3dJNI.strlwr__SWIG_1(str);
  }

  public static SWIGTYPE_p_std__string strupr(SWIGTYPE_p_std__string str) {
    return new SWIGTYPE_p_std__string(nel3dJNI.strupr__SWIG_0(SWIGTYPE_p_std__string.getCPtr(str)), false);
  }

  public static String strupr(String str) {
    return nel3dJNI.strupr__SWIG_1(str);
  }

  public static int stricmp(String lhs, String rhs) {
    return nel3dJNI.stricmp(lhs, rhs);
  }

  public static int strnicmp(String lhs, String rhs, long n) {
    return nel3dJNI.strnicmp(lhs, rhs, n);
  }

  public static int nlstricmp(String lhs, String rhs) {
    return nel3dJNI.nlstricmp__SWIG_0(lhs, rhs);
  }

  public static int nlfseek64(SWIGTYPE_p_FILE stream, long offset, int origin) {
    return nel3dJNI.nlfseek64(SWIGTYPE_p_FILE.getCPtr(stream), offset, origin);
  }

  public static long nlftell64(SWIGTYPE_p_FILE stream) {
    return nel3dJNI.nlftell64(SWIGTYPE_p_FILE.getCPtr(stream));
  }

  public static void nlSleep(long ms) {
    nel3dJNI.nlSleep(ms);
  }

  public static long getThreadId() {
    return nel3dJNI.getThreadId();
  }

  public static String stringFromVector(SWIGTYPE_p_std__vectorT_unsigned_char_t v, boolean limited) {
    return nel3dJNI.stringFromVector__SWIG_0(SWIGTYPE_p_std__vectorT_unsigned_char_t.getCPtr(v), limited);
  }

  public static String stringFromVector(SWIGTYPE_p_std__vectorT_unsigned_char_t v) {
    return nel3dJNI.stringFromVector__SWIG_1(SWIGTYPE_p_std__vectorT_unsigned_char_t.getCPtr(v));
  }

  public static long atoiInt64(String ident, long base) {
    return nel3dJNI.atoiInt64__SWIG_0(ident, base);
  }

  public static long atoiInt64(String ident) {
    return nel3dJNI.atoiInt64__SWIG_1(ident);
  }

  public static void itoaInt64(long number, String str, long base) {
    nel3dJNI.itoaInt64__SWIG_0(number, str, base);
  }

  public static void itoaInt64(long number, String str) {
    nel3dJNI.itoaInt64__SWIG_1(number, str);
  }

  public static String bytesToHumanReadable(String bytes) {
    return nel3dJNI.bytesToHumanReadable__SWIG_0(bytes);
  }

  public static String bytesToHumanReadable(java.math.BigInteger bytes) {
    return nel3dJNI.bytesToHumanReadable__SWIG_1(bytes);
  }

  public static long humanReadableToBytes(String str) {
    return nel3dJNI.humanReadableToBytes(str);
  }

  public static String secondsToHumanReadable(long time) {
    return nel3dJNI.secondsToHumanReadable(time);
  }

  public static long fromHumanReadable(String str) {
    return nel3dJNI.fromHumanReadable(str);
  }

  public static boolean launchProgram(String programName, String arguments) {
    return nel3dJNI.launchProgram(programName, arguments);
  }

  public static boolean killProgram(long pid) {
    return nel3dJNI.killProgram(pid);
  }

  public static boolean abortProgram(long pid) {
    return nel3dJNI.abortProgram(pid);
  }

  public static void displayByteBits(short b, long nbits, int beginpos, boolean displayBegin, SWIGTYPE_p_NLMISC__CLog log) {
    nel3dJNI.displayByteBits(b, nbits, beginpos, displayBegin, SWIGTYPE_p_NLMISC__CLog.getCPtr(log));
  }

  public static void displayDwordBits(long b, long nbits, int beginpos, boolean displayBegin, SWIGTYPE_p_NLMISC__CLog log) {
    nel3dJNI.displayDwordBits(b, nbits, beginpos, displayBegin, SWIGTYPE_p_NLMISC__CLog.getCPtr(log));
  }

  public static boolean openURL(String url) {
    return nel3dJNI.openURL(url);
  }

  public static boolean openDoc(String document) {
    return nel3dJNI.openDoc(document);
  }

  public static float favoid0(float x) {
    return nel3dJNI.favoid0(x);
  }

  public static double davoid0(double x) {
    return nel3dJNI.davoid0(x);
  }

  public static CUV mul(float f, CUV uv) {
    return new CUV(nel3dJNI.mul__SWIG_0(f, CUV.getCPtr(uv), uv), true);
  }

  public static CUV mul(CUV uv, float f) {
    return new CUV(nel3dJNI.mul__SWIG_1(CUV.getCPtr(uv), uv, f), true);
  }

  public static CUV blend(CUV uv0, CUV uv1, float lambda) {
    return new CUV(nel3dJNI.blend__SWIG_1(CUV.getCPtr(uv0), uv0, CUV.getCPtr(uv1), uv1, lambda), true);
  }

  public static CRGBAF mul(float f, CRGBAF c) {
    return new CRGBAF(nel3dJNI.mul__SWIG_2(f, CRGBAF.getCPtr(c), c), true);
  }

  public static SWIGTYPE_p_NLMISC__CClassId getCameraId() {
    return new SWIGTYPE_p_NLMISC__CClassId(nel3dJNI.CameraId_get(), true);
  }

  public static SWIGTYPE_p_NLMISC__CClassId getClusterId() {
    return new SWIGTYPE_p_NLMISC__CClassId(nel3dJNI.ClusterId_get(), true);
  }

  public static CTextureCube BuildCubeMap(int mapSize, ICubeMapFunctor f, boolean luminanceOnly, String shareName) {
    long cPtr = nel3dJNI.BuildCubeMap__SWIG_0(mapSize, ICubeMapFunctor.getCPtr(f), f, luminanceOnly, shareName);
    return (cPtr == 0) ? null : new CTextureCube(cPtr, false);
  }

  public static CTextureCube BuildCubeMap(int mapSize, ICubeMapFunctor f, boolean luminanceOnly) {
    long cPtr = nel3dJNI.BuildCubeMap__SWIG_1(mapSize, ICubeMapFunctor.getCPtr(f), f, luminanceOnly);
    return (cPtr == 0) ? null : new CTextureCube(cPtr, false);
  }

  public static CTextureCube BuildCubeMap(int mapSize, ICubeMapFunctor f) {
    long cPtr = nel3dJNI.BuildCubeMap__SWIG_2(mapSize, ICubeMapFunctor.getCPtr(f), f);
    return (cPtr == 0) ? null : new CTextureCube(cPtr, false);
  }

  public static void nlCheckVertexBuffer(CVertexBuffer vb, SWIGTYPE_p_unsigned_char ptr) {
    nel3dJNI.nlCheckVertexBuffer(CVertexBuffer.getCPtr(vb), vb, SWIGTYPE_p_unsigned_char.getCPtr(ptr));
  }

  public static void nlCheckVBA(CVertexBufferRead vbr, SWIGTYPE_p_unsigned_char ptr) {
    nel3dJNI.nlCheckVBA__SWIG_0(CVertexBufferRead.getCPtr(vbr), vbr, SWIGTYPE_p_unsigned_char.getCPtr(ptr));
  }

  public static void nlCheckVBA(CVertexBufferReadWrite vbrw, SWIGTYPE_p_unsigned_char ptr) {
    nel3dJNI.nlCheckVBA__SWIG_1(CVertexBufferReadWrite.getCPtr(vbrw), vbrw, SWIGTYPE_p_unsigned_char.getCPtr(ptr));
  }

  public static void nlCheckVBARange(CVertexBufferRead vbr, SWIGTYPE_p_unsigned_char ptStart, long length) {
    nel3dJNI.nlCheckVBARange__SWIG_0(CVertexBufferRead.getCPtr(vbr), vbr, SWIGTYPE_p_unsigned_char.getCPtr(ptStart), length);
  }

  public static void nlCheckVBARange(CVertexBufferReadWrite vbrw, SWIGTYPE_p_unsigned_char ptStart, long length) {
    nel3dJNI.nlCheckVBARange__SWIG_1(CVertexBufferReadWrite.getCPtr(vbrw), vbrw, SWIGTYPE_p_unsigned_char.getCPtr(ptStart), length);
  }

  public static void nlCheckIBARange(CIndexBufferReadWrite ibrw, SWIGTYPE_p_unsigned_char ptStart, long length) {
    nel3dJNI.nlCheckIBARange__SWIG_0(CIndexBufferReadWrite.getCPtr(ibrw), ibrw, SWIGTYPE_p_unsigned_char.getCPtr(ptStart), length);
  }

  public static void nlCheckIBARange(CIndexBufferRead ibr, SWIGTYPE_p_unsigned_char ptStart, long length) {
    nel3dJNI.nlCheckIBARange__SWIG_1(CIndexBufferRead.getCPtr(ibr), ibr, SWIGTYPE_p_unsigned_char.getCPtr(ptStart), length);
  }

  public static void nlCheckIBA(CIndexBufferReadWrite ibrw, SWIGTYPE_p_unsigned_char ptStart) {
    nel3dJNI.nlCheckIBA__SWIG_0(CIndexBufferReadWrite.getCPtr(ibrw), ibrw, SWIGTYPE_p_unsigned_char.getCPtr(ptStart));
  }

  public static void nlCheckIBA(CIndexBufferRead ibrw, SWIGTYPE_p_unsigned_char ptStart) {
    nel3dJNI.nlCheckIBA__SWIG_1(CIndexBufferRead.getCPtr(ibrw), ibrw, SWIGTYPE_p_unsigned_char.getCPtr(ptStart));
  }

  public static SWIGTYPE_p_NLMISC__CClassId getFlareModelClassId() {
    return new SWIGTYPE_p_NLMISC__CClassId(nel3dJNI.FlareModelClassId_get(), true);
  }

  public static long getMaxFlareNum() {
    return nel3dJNI.MaxFlareNum_get();
  }

  public static void init3d() {
    nel3dJNI.init3d();
  }

  public static int getNbTilesMax() {
    return nel3dJNI.NbTilesMax_get();
  }

  public static int getTextureNearSize() {
    return nel3dJNI.TextureNearSize_get();
  }

  public static int getNbTileLightMapByLine() {
    return nel3dJNI.NbTileLightMapByLine_get();
  }

  public static int getNbTileLightMapByTexture() {
    return nel3dJNI.NbTileLightMapByTexture_get();
  }

  public static void setNL3D_LandscapeGlobals_PassNTri(long value) {
    nel3dJNI.NL3D_LandscapeGlobals_PassNTri_set(value);
  }

  public static long getNL3D_LandscapeGlobals_PassNTri() {
    return nel3dJNI.NL3D_LandscapeGlobals_PassNTri_get();
  }

  public static void setNL3D_LandscapeGlobals_PassTriCurPtr(SWIGTYPE_p_void value) {
    nel3dJNI.NL3D_LandscapeGlobals_PassTriCurPtr_set(SWIGTYPE_p_void.getCPtr(value));
  }

  public static SWIGTYPE_p_void getNL3D_LandscapeGlobals_PassTriCurPtr() {
    long cPtr = nel3dJNI.NL3D_LandscapeGlobals_PassTriCurPtr_get();
    return (cPtr == 0) ? null : new SWIGTYPE_p_void(cPtr, false);
  }

  public static void setNL3D_LandscapeGlobals_PassTriFormat(CIndexBuffer.TFormat value) {
    nel3dJNI.NL3D_LandscapeGlobals_PassTriFormat_set(value.swigValue());
  }

  public static CIndexBuffer.TFormat getNL3D_LandscapeGlobals_PassTriFormat() {
    return CIndexBuffer.TFormat.swigToEnum(nel3dJNI.NL3D_LandscapeGlobals_PassTriFormat_get());
  }

  public static SWIGTYPE_p_NLMISC__CClassId getLandscapeModelId() {
    return new SWIGTYPE_p_NLMISC__CClassId(nel3dJNI.LandscapeModelId_get(), true);
  }

  public static void setProfNTessFace(int value) {
    nel3dJNI.ProfNTessFace_set(value);
  }

  public static int getProfNTessFace() {
    return nel3dJNI.ProfNTessFace_get();
  }

  public static void setProfNRdrFar0(int value) {
    nel3dJNI.ProfNRdrFar0_set(value);
  }

  public static int getProfNRdrFar0() {
    return nel3dJNI.ProfNRdrFar0_get();
  }

  public static void setProfNRdrFar1(int value) {
    nel3dJNI.ProfNRdrFar1_set(value);
  }

  public static int getProfNRdrFar1() {
    return nel3dJNI.ProfNRdrFar1_get();
  }

  public static void setProfNRdrTile(SWIGTYPE_p_int value) {
    nel3dJNI.ProfNRdrTile_set(SWIGTYPE_p_int.getCPtr(value));
  }

  public static SWIGTYPE_p_int getProfNRdrTile() {
    long cPtr = nel3dJNI.ProfNRdrTile_get();
    return (cPtr == 0) ? null : new SWIGTYPE_p_int(cPtr, false);
  }

  public static void setProfNRefineFaces(int value) {
    nel3dJNI.ProfNRefineFaces_set(value);
  }

  public static int getProfNRefineFaces() {
    return nel3dJNI.ProfNRefineFaces_get();
  }

  public static void setProfNRefineComputeFaces(int value) {
    nel3dJNI.ProfNRefineComputeFaces_set(value);
  }

  public static int getProfNRefineComputeFaces() {
    return nel3dJNI.ProfNRefineComputeFaces_get();
  }

  public static void setProfNRefineLeaves(int value) {
    nel3dJNI.ProfNRefineLeaves_set(value);
  }

  public static int getProfNRefineLeaves() {
    return nel3dJNI.ProfNRefineLeaves_get();
  }

  public static void setProfNSplits(int value) {
    nel3dJNI.ProfNSplits_set(value);
  }

  public static int getProfNSplits() {
    return nel3dJNI.ProfNSplits_get();
  }

  public static void setProfNMerges(int value) {
    nel3dJNI.ProfNMerges_set(value);
  }

  public static int getProfNMerges() {
    return nel3dJNI.ProfNMerges_get();
  }

  public static void setProfNRefineInTileTransition(int value) {
    nel3dJNI.ProfNRefineInTileTransition_set(value);
  }

  public static int getProfNRefineInTileTransition() {
    return nel3dJNI.ProfNRefineInTileTransition_get();
  }

  public static void setProfNRefineWithLowDistance(int value) {
    nel3dJNI.ProfNRefineWithLowDistance_set(value);
  }

  public static int getProfNRefineWithLowDistance() {
    return nel3dJNI.ProfNRefineWithLowDistance_get();
  }

  public static void setProfNSplitsPass(int value) {
    nel3dJNI.ProfNSplitsPass_set(value);
  }

  public static int getProfNSplitsPass() {
    return nel3dJNI.ProfNSplitsPass_get();
  }

  public static void setProfNTileSetupMaterial(int value) {
    nel3dJNI.ProfNTileSetupMaterial_set(value);
  }

  public static int getProfNTileSetupMaterial() {
    return nel3dJNI.ProfNTileSetupMaterial_get();
  }

  public static void setProfNFar0SetupMaterial(int value) {
    nel3dJNI.ProfNFar0SetupMaterial_set(value);
  }

  public static int getProfNFar0SetupMaterial() {
    return nel3dJNI.ProfNFar0SetupMaterial_get();
  }

  public static void setProfNFar1SetupMaterial(int value) {
    nel3dJNI.ProfNFar1SetupMaterial_set(value);
  }

  public static int getProfNFar1SetupMaterial() {
    return nel3dJNI.ProfNFar1SetupMaterial_get();
  }

  public static void setProfNPatchRdrFar0(int value) {
    nel3dJNI.ProfNPatchRdrFar0_set(value);
  }

  public static int getProfNPatchRdrFar0() {
    return nel3dJNI.ProfNPatchRdrFar0_get();
  }

  public static void setProfNPatchRdrFar1(int value) {
    nel3dJNI.ProfNPatchRdrFar1_set(value);
  }

  public static int getProfNPatchRdrFar1() {
    return nel3dJNI.ProfNPatchRdrFar1_get();
  }

  public static long getIDRV_MAT_MAXTEXTURES() {
    return nel3dJNI.IDRV_MAT_MAXTEXTURES_get();
  }

  public static long getIDRV_TOUCHED_BLENDFUNC() {
    return nel3dJNI.IDRV_TOUCHED_BLENDFUNC_get();
  }

  public static long getIDRV_TOUCHED_BLEND() {
    return nel3dJNI.IDRV_TOUCHED_BLEND_get();
  }

  public static long getIDRV_TOUCHED_SHADER() {
    return nel3dJNI.IDRV_TOUCHED_SHADER_get();
  }

  public static long getIDRV_TOUCHED_ZFUNC() {
    return nel3dJNI.IDRV_TOUCHED_ZFUNC_get();
  }

  public static long getIDRV_TOUCHED_ZBIAS() {
    return nel3dJNI.IDRV_TOUCHED_ZBIAS_get();
  }

  public static long getIDRV_TOUCHED_COLOR() {
    return nel3dJNI.IDRV_TOUCHED_COLOR_get();
  }

  public static long getIDRV_TOUCHED_LIGHTING() {
    return nel3dJNI.IDRV_TOUCHED_LIGHTING_get();
  }

  public static long getIDRV_TOUCHED_DEFMAT() {
    return nel3dJNI.IDRV_TOUCHED_DEFMAT_get();
  }

  public static long getIDRV_TOUCHED_ZWRITE() {
    return nel3dJNI.IDRV_TOUCHED_ZWRITE_get();
  }

  public static long getIDRV_TOUCHED_DOUBLE_SIDED() {
    return nel3dJNI.IDRV_TOUCHED_DOUBLE_SIDED_get();
  }

  public static long getIDRV_TOUCHED_LIGHTMAP() {
    return nel3dJNI.IDRV_TOUCHED_LIGHTMAP_get();
  }

  public static long getIDRV_TOUCHED_ALPHA_TEST() {
    return nel3dJNI.IDRV_TOUCHED_ALPHA_TEST_get();
  }

  public static long getIDRV_TOUCHED_ALPHA_TEST_THRE() {
    return nel3dJNI.IDRV_TOUCHED_ALPHA_TEST_THRE_get();
  }

  public static long getIDRV_TOUCHED_TEXENV() {
    return nel3dJNI.IDRV_TOUCHED_TEXENV_get();
  }

  public static long getIDRV_TOUCHED_TEXGEN() {
    return nel3dJNI.IDRV_TOUCHED_TEXGEN_get();
  }

  public static SWIGTYPE_p_unsigned_int getIDRV_TOUCHED_TEX() {
    long cPtr = nel3dJNI.IDRV_TOUCHED_TEX_get();
    return (cPtr == 0) ? null : new SWIGTYPE_p_unsigned_int(cPtr, false);
  }

  public static long getIDRV_TOUCHED_ALLTEX() {
    return nel3dJNI.IDRV_TOUCHED_ALLTEX_get();
  }

  public static long getIDRV_TOUCHED_ALL() {
    return nel3dJNI.IDRV_TOUCHED_ALL_get();
  }

  public static long getIDRV_MAT_HIDE() {
    return nel3dJNI.IDRV_MAT_HIDE_get();
  }

  public static long getIDRV_MAT_TSP() {
    return nel3dJNI.IDRV_MAT_TSP_get();
  }

  public static long getIDRV_MAT_ZWRITE() {
    return nel3dJNI.IDRV_MAT_ZWRITE_get();
  }

  public static long getIDRV_MAT_ZLIST() {
    return nel3dJNI.IDRV_MAT_ZLIST_get();
  }

  public static long getIDRV_MAT_LIGHTING() {
    return nel3dJNI.IDRV_MAT_LIGHTING_get();
  }

  public static long getIDRV_MAT_SPECULAR() {
    return nel3dJNI.IDRV_MAT_SPECULAR_get();
  }

  public static long getIDRV_MAT_DEFMAT() {
    return nel3dJNI.IDRV_MAT_DEFMAT_get();
  }

  public static long getIDRV_MAT_BLEND() {
    return nel3dJNI.IDRV_MAT_BLEND_get();
  }

  public static long getIDRV_MAT_DOUBLE_SIDED() {
    return nel3dJNI.IDRV_MAT_DOUBLE_SIDED_get();
  }

  public static long getIDRV_MAT_ALPHA_TEST() {
    return nel3dJNI.IDRV_MAT_ALPHA_TEST_get();
  }

  public static long getIDRV_MAT_TEX_ADDR() {
    return nel3dJNI.IDRV_MAT_TEX_ADDR_get();
  }

  public static long getIDRV_MAT_LIGHTED_VERTEX_COLOR() {
    return nel3dJNI.IDRV_MAT_LIGHTED_VERTEX_COLOR_get();
  }

  public static long getIDRV_MAT_GEN_TEX_0() {
    return nel3dJNI.IDRV_MAT_GEN_TEX_0_get();
  }

  public static long getIDRV_MAT_GEN_TEX_1() {
    return nel3dJNI.IDRV_MAT_GEN_TEX_1_get();
  }

  public static long getIDRV_MAT_GEN_TEX_2() {
    return nel3dJNI.IDRV_MAT_GEN_TEX_2_get();
  }

  public static long getIDRV_MAT_GEN_TEX_3() {
    return nel3dJNI.IDRV_MAT_GEN_TEX_3_get();
  }

  public static long getIDRV_MAT_GEN_TEX_4() {
    return nel3dJNI.IDRV_MAT_GEN_TEX_4_get();
  }

  public static long getIDRV_MAT_GEN_TEX_5() {
    return nel3dJNI.IDRV_MAT_GEN_TEX_5_get();
  }

  public static long getIDRV_MAT_GEN_TEX_6() {
    return nel3dJNI.IDRV_MAT_GEN_TEX_6_get();
  }

  public static long getIDRV_MAT_GEN_TEX_7() {
    return nel3dJNI.IDRV_MAT_GEN_TEX_7_get();
  }

  public static long getIDRV_MAT_USER_TEX_0_MAT() {
    return nel3dJNI.IDRV_MAT_USER_TEX_0_MAT_get();
  }

  public static long getIDRV_MAT_USER_TEX_1_MAT() {
    return nel3dJNI.IDRV_MAT_USER_TEX_1_MAT_get();
  }

  public static long getIDRV_MAT_USER_TEX_2_MAT() {
    return nel3dJNI.IDRV_MAT_USER_TEX_2_MAT_get();
  }

  public static long getIDRV_MAT_USER_TEX_3_MAT() {
    return nel3dJNI.IDRV_MAT_USER_TEX_3_MAT_get();
  }

  public static long getIDRV_MAT_USER_TEX_4_MAT() {
    return nel3dJNI.IDRV_MAT_USER_TEX_4_MAT_get();
  }

  public static long getIDRV_MAT_USER_TEX_5_MAT() {
    return nel3dJNI.IDRV_MAT_USER_TEX_5_MAT_get();
  }

  public static long getIDRV_MAT_USER_TEX_6_MAT() {
    return nel3dJNI.IDRV_MAT_USER_TEX_6_MAT_get();
  }

  public static long getIDRV_MAT_USER_TEX_7_MAT() {
    return nel3dJNI.IDRV_MAT_USER_TEX_7_MAT_get();
  }

  public static long getIDRV_MAT_USER_TEX_MAT_ALL() {
    return nel3dJNI.IDRV_MAT_USER_TEX_MAT_ALL_get();
  }

  public static long getIDRV_MAT_USER_TEX_FIRST_BIT() {
    return nel3dJNI.IDRV_MAT_USER_TEX_FIRST_BIT_get();
  }

  public static long getIDRV_MAT_TEX_GEN_SHIFT() {
    return nel3dJNI.IDRV_MAT_TEX_GEN_SHIFT_get();
  }

  public static long getIDRV_MAT_TEX_GEN_MASK() {
    return nel3dJNI.IDRV_MAT_TEX_GEN_MASK_get();
  }

  public static SWIGTYPE_p_NLMISC__CClassId getMeshBaseInstanceId() {
    return new SWIGTYPE_p_NLMISC__CClassId(nel3dJNI.MeshBaseInstanceId_get(), true);
  }

  public static SWIGTYPE_p_NLMISC__CClassId getMeshInstanceId() {
    return new SWIGTYPE_p_NLMISC__CClassId(nel3dJNI.MeshInstanceId_get(), true);
  }

  public static SWIGTYPE_p_NLMISC__CClassId getMeshMRMInstanceId() {
    return new SWIGTYPE_p_NLMISC__CClassId(nel3dJNI.MeshMRMInstanceId_get(), true);
  }

  public static SWIGTYPE_p_NLMISC__CClassId getMeshMRMSkinnedInstanceId() {
    return new SWIGTYPE_p_NLMISC__CClassId(nel3dJNI.MeshMRMSkinnedInstanceId_get(), true);
  }

  public static SWIGTYPE_p_NLMISC__CClassId getMeshMultiLodInstanceId() {
    return new SWIGTYPE_p_NLMISC__CClassId(nel3dJNI.MeshMultiLodInstanceId_get(), true);
  }

  public static long getMaxPSUserParam() {
    return nel3dJNI.MaxPSUserParam_get();
  }

  public static SWIGTYPE_p_NLMISC__CClassId getParticleSystemModelId() {
    return new SWIGTYPE_p_NLMISC__CClassId(nel3dJNI.ParticleSystemModelId_get(), true);
  }

  public static SWIGTYPE_p_NLMISC__CClassId getPointLightModelId() {
    return new SWIGTYPE_p_NLMISC__CClassId(nel3dJNI.PointLightModelId_get(), true);
  }

  public static float getMaxInputValue() {
    return nel3dJNI.MaxInputValue_get();
  }

  public static long getPSBinOpBufSize() {
    return nel3dJNI.PSBinOpBufSize_get();
  }

  public static void MakePrivate(SWIGTYPE_p_unsigned_char dest, CRGBA src1, CRGBA src2, long stride, long numAttrib, CPSBinOp.BinOp op) {
    nel3dJNI.MakePrivate(SWIGTYPE_p_unsigned_char.getCPtr(dest), CRGBA.getCPtr(src1), src1, CRGBA.getCPtr(src2), src2, stride, numAttrib, op.swigValue());
  }

  public static void Make4Private(SWIGTYPE_p_unsigned_char dest, CRGBA src1, CRGBA src2, long stride, long numAttrib, CPSBinOp.BinOp op) {
    nel3dJNI.Make4Private(SWIGTYPE_p_unsigned_char.getCPtr(dest), CRGBA.getCPtr(src1), src1, CRGBA.getCPtr(src2), src2, stride, numAttrib, op.swigValue());
  }

  public static void MakeNPrivate(SWIGTYPE_p_unsigned_char dest, CRGBA src1, CRGBA src2, long stride, long numAttrib, CPSBinOp.BinOp op, long nbReplicate) {
    nel3dJNI.MakeNPrivate(SWIGTYPE_p_unsigned_char.getCPtr(dest), CRGBA.getCPtr(src1), src1, CRGBA.getCPtr(src2), src2, stride, numAttrib, op.swigValue(), nbReplicate);
  }

  public static CRGBA PSValueBlend(CRGBA t1, CRGBA t2, float alpha) {
    return new CRGBA(nel3dJNI.PSValueBlend__SWIG_1(CRGBA.getCPtr(t1), t1, CRGBA.getCPtr(t2), t2, alpha), true);
  }

  public static CPlaneBasis PSValueBlend(CPlaneBasis t1, CPlaneBasis t2, float alpha) {
    return new CPlaneBasis(nel3dJNI.PSValueBlend__SWIG_2(CPlaneBasis.getCPtr(t1), t1, CPlaneBasis.getCPtr(t2), t2, alpha), true);
  }

  public static void computeGradient(CRGBA valueTab, long numValues, long nbStages, SWIGTYPE_p_NL3D__CPSVectorT_NLMISC__CRGBA_t__V grad, CRGBA minValue, CRGBA maxValue) {
    nel3dJNI.computeGradient(CRGBA.getCPtr(valueTab), valueTab, numValues, nbStages, SWIGTYPE_p_NL3D__CPSVectorT_NLMISC__CRGBA_t__V.getCPtr(grad), CRGBA.getCPtr(minValue), minValue, CRGBA.getCPtr(maxValue), maxValue);
  }

  public static CRGBA convertVBColor(CRGBA color, CVertexBuffer.TVertexColorType format) {
    return new CRGBA(nel3dJNI.convertVBColor__SWIG_0(CRGBA.getCPtr(color), color, format.swigValue()), true);
  }

  public static void convertVBColor(CRGBA array, long numColor, CVertexBuffer.TVertexColorType format) {
    nel3dJNI.convertVBColor__SWIG_1(CRGBA.getCPtr(array), array, numColor, format.swigValue());
  }

  public static long getRGBA_BLENDER_NUM_VALUES() {
    return nel3dJNI.RGBA_BLENDER_NUM_VALUES_get();
  }

  public static String toString(CPSEmitter.TEmissionType type) {
    return nel3dJNI.toString(type.swigValue());
  }

  public static void setPSLookAtRenderTime(java.math.BigInteger value) {
    nel3dJNI.PSLookAtRenderTime_set(value);
  }

  public static java.math.BigInteger getPSLookAtRenderTime() {
    return nel3dJNI.PSLookAtRenderTime_get();
  }

  public static boolean lt(SWIGTYPE_p_NL3D__CPSFloatCurveFunctor__CCtrlPoint lhs, SWIGTYPE_p_NL3D__CPSFloatCurveFunctor__CCtrlPoint rhs) {
    return nel3dJNI.lt__SWIG_0(SWIGTYPE_p_NL3D__CPSFloatCurveFunctor__CCtrlPoint.getCPtr(lhs), SWIGTYPE_p_NL3D__CPSFloatCurveFunctor__CCtrlPoint.getCPtr(rhs));
  }

  public static long getDefaultMaxLocatedInstance() {
    return nel3dJNI.DefaultMaxLocatedInstance_get();
  }

  public static long getPSForce() {
    return nel3dJNI.PSForce_get();
  }

  public static long getPSParticle() {
    return nel3dJNI.PSParticle_get();
  }

  public static long getPSEmitter() {
    return nel3dJNI.PSEmitter_get();
  }

  public static long getPSLight() {
    return nel3dJNI.PSLight_get();
  }

  public static long getPSZone() {
    return nel3dJNI.PSZone_get();
  }

  public static long getPSSound() {
    return nel3dJNI.PSSound_get();
  }

  public static boolean lt(CPSLocatedBindable lhs, CPSLocatedBindable rhs) {
    return nel3dJNI.lt__SWIG_1(CPSLocatedBindable.getCPtr(lhs), lhs, CPSLocatedBindable.getCPtr(rhs), rhs);
  }

  public static long getConstraintMeshMaxNumVerts() {
    return nel3dJNI.ConstraintMeshMaxNumVerts_get();
  }

  public static long getConstraintMeshBufSize() {
    return nel3dJNI.ConstraintMeshBufSize_get();
  }

  public static long getConstraintMeshMaxNumPrerotatedModels() {
    return nel3dJNI.ConstraintMeshMaxNumPrerotatedModels_get();
  }

  public static long ScaleFloatGE(float f, float deltaT, float clampValue, long numStep) {
    return nel3dJNI.ScaleFloatGE(f, deltaT, clampValue, numStep);
  }

  public static CVector FillBufUsingSubdiv(CVector value, float clampValue, SWIGTYPE_p_float startValue, float deltaT, SWIGTYPE_p_unsigned_int maxNumStep, CVector destPos, long stride) {
    long cPtr = nel3dJNI.FillBufUsingSubdiv(CVector.getCPtr(value), value, clampValue, SWIGTYPE_p_float.getCPtr(startValue), deltaT, SWIGTYPE_p_unsigned_int.getCPtr(maxNumStep), CVector.getCPtr(destPos), destPos, stride);
    return (cPtr == 0) ? null : new CVector(cPtr, false);
  }

  public static void SetupModulatedStage(CMaterial m, long stage, CMaterial.TTexSource src1, CMaterial.TTexSource src2) {
    nel3dJNI.SetupModulatedStage(CMaterial.getCPtr(m), m, stage, src1.swigValue(), src2.swigValue());
  }

  public static boolean lt(CPlaneBasis p1, CPlaneBasis p2) {
    return nel3dJNI.lt__SWIG_2(CPlaneBasis.getCPtr(p1), p1, CPlaneBasis.getCPtr(p2), p2);
  }

  public static void PSRegisterColorAttribs() {
    nel3dJNI.PSRegisterColorAttribs();
  }

  public static void PSRegisterFloatAttribs() {
    nel3dJNI.PSRegisterFloatAttribs();
  }

  public static void PSRegisterIntAttribs() {
    nel3dJNI.PSRegisterIntAttribs();
  }

  public static void PSRegisterPlaneBasisAttribs() {
    nel3dJNI.PSRegisterPlaneBasisAttribs();
  }

  public static float getPSCollideEpsilon() {
    return nel3dJNI.PSCollideEpsilon_get();
  }

  public static SWIGTYPE_p_NLMISC__CClassId getQuadGridClipManagerId() {
    return new SWIGTYPE_p_NLMISC__CClassId(nel3dJNI.QuadGridClipManagerId_get(), true);
  }

  public static void registerSerial3d() {
    nel3dJNI.registerSerial3d();
  }

  public static SWIGTYPE_p_NLMISC__CClassId getRootModelId() {
    return new SWIGTYPE_p_NLMISC__CClassId(nel3dJNI.RootModelId_get(), true);
  }

  public static String standardizeShapeName(String name) {
    return nel3dJNI.standardizeShapeName(name);
  }

  public static SWIGTYPE_p_NLMISC__CClassId getSkeletonModelId() {
    return new SWIGTYPE_p_NLMISC__CClassId(nel3dJNI.SkeletonModelId_get(), true);
  }

  public static boolean BuildTangentSpace(SWIGTYPE_p_NL3D__CMesh__CMeshBuild outMeshBuild, SWIGTYPE_p_NL3D__CMesh__CMeshBuild inMeshBuild) {
    return nel3dJNI.BuildTangentSpace(SWIGTYPE_p_NL3D__CMesh__CMeshBuild.getCPtr(outMeshBuild), SWIGTYPE_p_NL3D__CMesh__CMeshBuild.getCPtr(inMeshBuild));
  }

  public static float getOO32768() {
    return nel3dJNI.OO32768_get();
  }

  public static void NL3D_expandLightmap(NL3D_CExpandLightmap pLightmap) {
    nel3dJNI.NL3D_expandLightmap(NL3D_CExpandLightmap.getCPtr(pLightmap), pLightmap);
  }

  public static void NL3D_drawFarTileInFarTexture(NL3D_CComputeTileFar pTileFar) {
    nel3dJNI.NL3D_drawFarTileInFarTexture(NL3D_CComputeTileFar.getCPtr(pTileFar), pTileFar);
  }

  public static void NL3D_drawFarTileInFarTextureAdditive(NL3D_CComputeTileFar pTileFar) {
    nel3dJNI.NL3D_drawFarTileInFarTextureAdditive(NL3D_CComputeTileFar.getCPtr(pTileFar), pTileFar);
  }

  public static void NL3D_drawFarTileInFarTextureAlpha(NL3D_CComputeTileFar pTileFar) {
    nel3dJNI.NL3D_drawFarTileInFarTextureAlpha(NL3D_CComputeTileFar.getCPtr(pTileFar), pTileFar);
  }

  public static void NL3D_drawFarTileInFarTextureAdditiveAlpha(NL3D_CComputeTileFar pTileFar) {
    nel3dJNI.NL3D_drawFarTileInFarTextureAdditiveAlpha(NL3D_CComputeTileFar.getCPtr(pTileFar), pTileFar);
  }

  public static void copyToValue(CRGBA col, CVector v) {
    nel3dJNI.copyToValue__SWIG_1(CRGBA.getCPtr(col), col, CVector.getCPtr(v), v);
  }

  public static void copyToValue(SWIGTYPE_p_int value, float f) {
    nel3dJNI.copyToValue__SWIG_2(SWIGTYPE_p_int.getCPtr(value), f);
  }

  public static SWIGTYPE_p_NLMISC__CClassId getTransformId() {
    return new SWIGTYPE_p_NLMISC__CClassId(nel3dJNI.TransformId_get(), true);
  }

  public static SWIGTYPE_p_NLMISC__CClassId getTransformShapeId() {
    return new SWIGTYPE_p_NLMISC__CClassId(nel3dJNI.TransformShapeId_get(), true);
  }

  public static void assignSoundServerToPS(UPSSoundServer soundServer) {
    nel3dJNI.assignSoundServerToPS(UPSSoundServer.getCPtr(soundServer), soundServer);
  }

  public static void SpawnedSourceEndedCallback(SWIGTYPE_p_NLSOUND__USource source, SWIGTYPE_p_void userParam) {
    nel3dJNI.SpawnedSourceEndedCallback(SWIGTYPE_p_NLSOUND__USource.getCPtr(source), SWIGTYPE_p_void.getCPtr(userParam));
  }

  public static SWIGTYPE_p_NLMISC__CClassId getVegetableBlendLayerModelId() {
    return new SWIGTYPE_p_NLMISC__CClassId(nel3dJNI.VegetableBlendLayerModelId_get(), true);
  }

  public static long getNumWaterMap() {
    return nel3dJNI.NumWaterMap_get();
  }

  public static CWaterPoolManager GetWaterPoolManager() {
    return new CWaterPoolManager(nel3dJNI.GetWaterPoolManager(), false);
  }

  public static SWIGTYPE_p_NLMISC__CClassId getWaterModelClassId() {
    return new SWIGTYPE_p_NLMISC__CClassId(nel3dJNI.WaterModelClassId_get(), true);
  }

  public static SWIGTYPE_p_NLMISC__CClassId getWaveMakerModelClassId() {
    return new SWIGTYPE_p_NLMISC__CClassId(nel3dJNI.WaveMakerModelClassId_get(), true);
  }

  public static long getWATER_VERTEX_HARD_SIZE() {
    return nel3dJNI.WATER_VERTEX_HARD_SIZE_get();
  }

  public static long getWATER_VERTEX_SOFT_SIZE() {
    return nel3dJNI.WATER_VERTEX_SOFT_SIZE_get();
  }

}
